#pragma once
#include "Sock.hpp"
#include <functional>
#include<iostream>
#include <pthread.h>
#include <string>
#include <sys/socket.h>
#include <vector>
#include<unistd.h>

namespace yangyi
{
    using func_t = std::function<void(int)>;
    class TcpServer;
    class ThreadData
    {
    public:
        ThreadData(int sock,TcpServer* server)
        :_sock(sock)
        ,_server(server)
        {

        }
        ~ThreadData(){

        }
    public:
        int _sock;
        TcpServer* _server;
    };

    class TcpServer
    {
    private:
        static void* ThreadRoutine()
        {
            
        }
    public:
        TcpServer(uint16_t port,std::string ip)
        {
            _serversock=_sock.Socket();
            _sock.Bind(_serversock,port,ip);
            _sock.Listen(_serversock);
        }
        void WorkerServer(func_t callback)
        {
            _func.push_back(callback);
        }
        void Excute(int sock)
        {
            for(auto& iter:_func){
                iter(sock);
            }
        }
        void Start()
        {
            while(true)
            {
                std::string clientip;
                uint16_t clientport;
                int sock=_sock.Accept(_serversock,&clientport,&clientip);
                if(sock == -1){
                    continue;
                }
                pthread_t tid;
                ThreadData* td=new ThreadData(sock,this);
                pthread_create(&tid, nullptr, ThreadRoutine, (void*)td);
            }
        }
    private:
        int _serversock;
        Sock _sock;
        std::vector<func_t> _func;
    };
}
// namespace yangyi
// {
//     using func_t = std::function<void(int)>;
    
//     class TcpServer;
//     class ThreadData
//     {
//     public:
//         ThreadData(int sock,TcpServer* server)
//         :_sock(sock)
//         ,_server(server)
//         {

//         }
//         ~ThreadData(){}
//     public:
//         int _sock;
//         TcpServer* _server;
//     };

//     class TcpServer
//     {
//     private:
//         static void* ThreadRoutine(void* args)
//         {
//             pthread_detach(pthread_self());
//             ThreadData* td=static_cast<ThreadData*>(args);
//             td->_server->Excute(td->_sock);
//             close(td->_sock);
//             return nullptr;
//         }
//     public:
//         TcpServer(const uint16_t& port,const std::string& ip)
//         {
//             _listensock=_sock.Socket();
//             _sock.Bind(_listensock,port,ip);
//             _sock.Listen(_listensock);
//         }
//         //这里的TCP通信要执行多个不同的任务
//         void WorkerTcpServer(func_t callback)
//         {
//             _func.push_back(callback);
//         }
//         void Excute(int sock)
//         {
//             for(auto& iter:_func)
//             {
//                 iter(sock);
//             }
//         }
//         void Start()
//         {
//             while(true)
//             {
//                 std::string clientip;
//                 uint16_t clientport;
//                 int sock=_sock.Accept(_listensock,&clientport,&clientip);
//                 if(sock == -1){
//                     continue;
//                 }
//                 pthread_t tid;
//                 ThreadData* td=new ThreadData(sock,this);
//                 //让这个线程在这个sock文件里面执行固定的任务
//                 pthread_create(&tid,nullptr,ThreadRoutine,(void*)td);
//             }
//         }
//     private:
//         int _listensock;
//         Sock _sock;
//         std::vector<func_t> _func;
//     };
// }
// using func_t = std::function<void(int)>;
// namespace yangyi
// {
//     class TcpServer;
//     class ThreadData
//     {
//     ThreadData(int sock,TcpServer* server)
//     :_serversock(sock)
//     ,_server(server)
//     {

//     }
//     private:
//         int _serversock;
//         TcpServer* _server;
//     };
//     class TcpServer
//     {
//     public: 
//         TcpServer(const uint16_t& port,std::string& ip)
//         {
//             _serversock=_sock.Socket();
//             _sock.Bind(_serversock,port,ip);
//             _sock.Listen(_serversock);
//         }
//         void WorkerServer(func_t callback)
//         {
//             _func.push_back(callback);
//         }
//         void Excute(int sock)
//         {
//             for(auto& iter:_func){
//                 iter(sock);
//             }
//         }
//         void Start()
//         {
//             while(true)
//             {
//                 std::string clientip;
//                 uint16_t clientport;
//                 int sock=_sock.Accept(_serversock,&clientport,&clientip);
//                 if(_sock == -1){
//                     continue;
//                 }
//                 pthread_t tid;
//                 ThreadData* td=new ThreadData(sock,this);
//             }
//         }
//     private:
//         int _serversock;
//         Sock _sock;
//         std::vector<func_t> _func;
//     };
// }
// namespace yangyi
// {
//     using func_t =std::function<void(int)>;
//     class TcpServer;
//     class ThreadData
//     {
//     public:
//         ThreadData(int sock,TcpServer* server)
//         :_sock(sock)
//         ,_server(server)
//         {

//         }
//         ~ThreadData(){}
//     public:
//         int _sock;
//         TcpServer* _server;
//     };
//     class TcpServer
//     {
//     public:
//         TcpServer(const uint16_t& port,const std::string& ip="")
//         {
//             _serversock=_sock.Socket();
//             _sock.Bind();
//             _sock.Listen();
//         }
//         //这里是绑定方法
//         void WorkerServer(func_t callback)
//         {
//             _func.push_back(callback);
//         }
//         void Excute(int sock)
//         {
//             for(auto& iter:_func){
//                 iter(sock);
//             }
//         }
//         void Start()
//         {
//             while(true)
//             {
//                 std::string clientip;
//                 uint16_t clientport;
//                 int sock=_sock.Socket(_serversock,clientport,clientip);
//                 if(sock == -1){
//                     continue;
//                 }
//                 pthread_t tid;
//                 ThreadData* td=new ThreadData(sock,this);
//                 pthread_create(&tid, nullptr, ThreadRoutine,(void*)td);
//             }
//         }
//         ~TcpServer(){
//             if(_serversock >= 0){
//                 close(_serversock);
//             }
//         }
//         // void Start()
//         // {
//         //     while(true)
//         //     {
//         //         std::string clientip;
//         //         uint16_t clientport;
//         //         int sock=_sock.Accept(_serversock,&clientport,&clientip);
//         //         if(sock ==-1){continue;}
//         //         pthread_t tid;
//         //         ThreadData* td=new ThreadData(sock,this);
//         //         pthread_create(&tid, nullptr, ThreadRoutine,td);
//         //     }
//         // }
//     private:
//         static void* ThreadRoutine(void* args)
//         {
//             pthread_detach(pthread_self());
//             ThreadData* td=static_cast<ThreadData*>(args);
            
//         }
//         int _serversock;
//         Sock _sock;
//         std::vector<func_t> _func;
//     };
// }
// namespace tcp_server
// {
//     using func_t=std::function<void(int)>;
//     class TcpServer;

//     class ThreadData
//     {
//     public:
//         ThreadData(int sock,TcpServer* server)
//         :_sock(sock)
//         ,_server(server)
//         {

//         }
//     public:
//         int _sock;
//         TcpServer* _server;
//     };

//     class TcpServer
//     {
//     private:
//         int _sock;
//         std::vector<func_t> _func;
//     };
// }
